package com.chushouya.order.service.common.impl;

import com.chushouya.manager.config.BizConfigEnum;
import com.chushouya.manager.service.common.ConfigApiService;
import com.chushouya.order.constants.OrderTypeEnum;
import com.chushouya.order.service.common.SuhuishouSyncService;
import com.general.framework.core.lang.Jsons;
import com.general.framework.core.lang.Lists;
import com.general.framework.core.lang.Longs;
import com.general.framework.core.lang.Strings;
import com.google.common.base.Objects;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;

/**
 * 速回收同步判断服务实现
 * 
 * @author system
 * @date 2024-09-23
 */
@Slf4j
@Service
public class SuhuishouSyncServiceImpl implements SuhuishouSyncService {

    @Resource
    private ConfigApiService configApiService;

    @Override
    public boolean canSyncToSuhuishou(Integer orderType, BigDecimal orderPrice, String userPhone, Long cityCode) {
        log.info("开始判断订单是否可以同步给速回收，上门类型{},订单金额: {}, 用户手机号: {}, 城市编码: {}", orderType,
                orderPrice, userPhone, cityCode);
        if (Objects.equal(orderType, OrderTypeEnum.DOOR_RECYCLE.value())){
            log.info("订单类型为上门回收，同步给速回收");
            return true;
        }
        try {
            // 1. 验证订单金额
            if (!validateOrderPrice(orderPrice)) {
                return false;
            }

            // 2. 验证城市限制
            if (!validateCityCode(cityCode)) {
                return false;
            }

            // 3. 验证用户手机号（可扩展其他用户相关验证）
            if (!validateUserPhone(userPhone)) {
                return false;
            }

            log.info("订单满足速回收同步条件，订单金额: {}, 用户手机号: {}, 城市编码: {}", 
                    orderPrice, userPhone, cityCode);
            return true;

        } catch (Exception e) {
            log.error("判断订单同步条件时发生异常，订单金额: {}, 用户手机号: {}, 城市编码: {}", 
                    orderPrice, userPhone, cityCode, e);
            return false;
        }
    }

    /**
     * 验证订单金额
     */
    private boolean validateOrderPrice(BigDecimal orderPrice) {
        if (orderPrice == null) {
            log.warn("订单金额为空，跳过验证");
            return true;
        }

        try {
            // 获取最低同步金额配置
            String minSyncPriceValue = configApiService.getStringConfig(
                    BizConfigEnum.MIN_SYNC_SUHUISHOU_ORDER_PRICE.getConfigKey());
            
            Integer minSyncPrice = 600; // 默认值600元
            if (Strings.isNotBlank(minSyncPriceValue)) {
                try {
                    minSyncPrice = Integer.valueOf(minSyncPriceValue);
                } catch (NumberFormatException e) {
                    log.warn("最低同步金额配置格式错误，使用默认值600元，配置值: {}", minSyncPriceValue);
                }
            }

            // 订单金额必须小于最低同步金额才能同步（低价订单同步给速回收）
            if (orderPrice.intValue() >= minSyncPrice) {
                log.info("订单金额{}元高于最低同步金额{}元，无法同步到速回收", 
                        orderPrice.intValue(), minSyncPrice);
                return false;
            }

            return true;

        } catch (Exception e) {
            log.error("验证订单金额时发生异常，订单金额: {}", orderPrice, e);
            return false;
        }
    }

    /**
     * 验证城市编码
     */
    private boolean validateCityCode(Long cityCode) {
        if (Longs.isNullOrZero(cityCode)) {
            log.warn("城市编码为空，跳过验证");
            return true;
        }

        try {
            // 获取不支持同步的城市列表配置
            String notOrderSyncJson = configApiService.getStringConfig(
                    BizConfigEnum.NOT_ORDER_SYNC_CITY.getConfigKey());
            
            if (Strings.isNotBlank(notOrderSyncJson)) {
                List<Long> notOrderSyncCityList = Jsons.parseArray(notOrderSyncJson, Long.class);
                
                if (Lists.isNotEmpty(notOrderSyncCityList)) {
                    if (notOrderSyncCityList.contains(cityCode)) {
                        log.info("城市编码{}不支持同步订单到速回收", cityCode);
                        return false;
                    }
                }
            }

            return true;

        } catch (Exception e) {
            log.error("验证城市编码时发生异常，城市编码: {}", cityCode, e);
            return false;
        }
    }

    /**
     * 验证用户手机号
     */
    private boolean validateUserPhone(String userPhone) {
        if (Strings.isBlank(userPhone)) {
            log.warn("用户手机号为空，跳过验证");
            return true;
        }

        // 基本的手机号格式验证
        if (!userPhone.matches("^1[3-9]\\d{9}$")) {
            log.warn("用户手机号格式不正确: {}", userPhone);
            return false;
        }

        try {
            // 获取忽略同步的手机号列表配置
            String ignoreMobileJson = configApiService.getStringConfig(
                    BizConfigEnum.IGNORE_SUHUISHOU_MOBILE.getConfigKey());
            
            if (Strings.isNotBlank(ignoreMobileJson)) {
                List<String> ignoreMobileList = Jsons.parseArray(ignoreMobileJson, String.class);
                
                if (ignoreMobileList != null && ignoreMobileList.contains(userPhone)) {
                    log.info("手机号{}在忽略同步列表中，无法同步到速回收", userPhone);
                    return false;
                }
            }

            return true;

        } catch (Exception e) {
            log.error("验证用户手机号时发生异常，手机号: {}", userPhone, e);
            return false;
        }
    }
}
